This PR brings a major rewrite of the Screen Space Reflection raymarching code, targetting performance optimization :

• Implements a DDA algorithm that marches the ray simultaneously in ndc and homogeneous view space, as described in "Efficient GPU Screen-Space Ray Tracing" (Morgan McGuire and al.).

• Produces a linear depth buffer during the scale pre-pass (this was actually already the case for the single-eye setup, but not for VR). In conjunction with homogeneous view space marching, this removes the need for any reprojection in the ray marching loop.

• Removes normal-roughness buffer fetches during marching, utilized to perform backface culling. This is now performed by comparing the current and previous samples' depth and rejecting hits when the ray exits the volume.

• Solves 2 issues :

  • rays didn't pass behind objects resulting in long hollow trails (see captures below). These are now gone and in the worst case replaced by smaller holes corresponding to the object footprint on the surface behind
  • SSR code doesn't depend anymore on any camera attributes reconstruction method (like Projection::get_z_far() or Projection::is_orthogonal()). These can break under certain circumstances, typically when the zfar / znear ratio is very large, the projection matrix becomes infinite and it's not possible to extract zfar anymore from it

• Hopefully improves code readability and establishes a good foundation for further improvements. A few ideas I leave to further PRs :

  • Ray striding and jittering, as described in the above paper. This allows marching farther with the same number of samples without deteriorating image quality too much
  • Add a binary search pass to refine the hit points as suggested here
  • Hierarchical-Z approaches involving pre-computed z-buffer mip-maps to speed up marching even further

Visual differences

Cube roughness is 0.2, floor roughness is 0.0.
Depth threshold is 0.1.
Raymarching 512 steps.

This is the single-eye case. Any help to test it in VR is welcome.
Also, any test with more complex scenes would be appreciated.

Before	With this PR

Performance improvements

These should be material for both single-eye and VR setups. Although I couldn't get it statistically measured (I couldn't sort out yet the render graph messing up debug markers, despite active support from @clayjohn @Ansraer and @DarioSamo), the GPU traces below show clues of a ~20% compute time reduction.

In this context, please take the below with a grain of salt as it is my interpretation (also please ignore the markers) :

1. might be the scale pass, left pretty much unchanged in single-eye setup
2. is likely the core ray marching logic, optimized by ~50% after this PR
3. looks like the filter pass, although it's pretty much left untouched by this PR and I don't get why it would be longer

Any help on making this analysis stronger is welcome.

Top chart : before
Bottom chart : with this PR